home *** CD-ROM | disk | FTP | other *** search
/ Aminet 6 / Aminet 6 - June 1995.iso / Aminet / misc / amag / AM95022.lha / c++-kurs-2 / Listing4.c < prev   
Encoding:
C/C++ Source or Header  |  1992-12-04  |  3.3 KB  |  142 lines
  1.  
  2. /*
  3.  * Listing4: © Clemens Marschner, 1994
  4.  * Ein Beispiel zur Template-Verwendung und zu überladenen
  5.  * Operatoren. Das Beispiel ist für jeden beliebigen Typ
  6.  * verwendbar, auf dem die Operatoren '>' und '=' verwendet
  7.  * werden können und die Stream-fähig sind.
  8.  */
  9.  
  10. // sorttemplate.c; (W)94 by Clemens Marschner
  11.  
  12. #include <stream.h>    // cout...
  13. #include <stdlib.h>    // rand()...
  14. #include <time.h>
  15. #include <string.h>    // strcpy()...
  16. #include <stdio.h>    // getchar()
  17.  
  18. // eine generische Array-Klasse. Der Klassenbibliothek sind
  19. // vollständige Versionen beigelegt (siehe classes/datastructures)
  20.  
  21. template <class T>    // T: beliebiger Platzhalter
  22. class array {
  23.     T *content;        // Zeiger auf Array vom Typ T
  24.     int size;        // Größe des Arrays
  25. public:
  26.     // der Konstruktor mit Größe und Default-Werten
  27.     array(int sz) { 
  28.         content = new T[size = sz];
  29.     }
  30.     ~array() { 
  31.         delete[] content;
  32.         // bei delete wird jeweils der Destruktor aufgerufen
  33.         // delete[] ist für Arrays notwendig!
  34.     }
  35.     T& operator[](int index) {
  36.         // gibt den Inhalt eines Arrayelements zurück
  37.         return content[index];
  38.     }
  39.     int Size() { return size; }
  40. };    
  41.  
  42. // eine einfache String-Klasse. Sie ist 
  43. // vollständig in tools/str.h zu finden
  44.  
  45. class String {
  46.     char*str;
  47. public:
  48.     void operator=(const char*s){ 
  49.         // Zuweisungs-Operator: er verhindert, daß zwei 
  50.         // String-Strukturen auf den gleichen String zeigen 
  51.         // (Absturz bei delete!)
  52.         str=new char[strlen(s)];
  53.         strcpy(str, s);
  54.     }
  55.     
  56.     String(const char*s=0) {
  57.         if(s) operator=(s) else str=0l; 
  58.     }
  59.  
  60.     ~String() { delete str; }
  61.  
  62.     int operator>(const String&s) {
  63.         return(strcmp(str, s.str) > 0 ? 1 : 0);
  64.     }
  65.     operator char*() { 
  66.         // hiermit können String-Klassen wie normale
  67.          // String-Zeiger behandelt werden
  68.         if(str) return str; 
  69.         else return ""; 
  70.     }
  71.     friend ostream& operator << (ostream&, const 
  72. String&);
  73. };
  74.  
  75. // durch den überladenen Shift-Operator können Strings
  76. // mit cout ausgegeben werden
  77. ostream& operator << (ostream&o, const String&s) {
  78.         return o << s.str;
  79. }
  80.  
  81. // Template-Funktion, um den Inhalt zweier Typen zu vertauschen
  82. template <class T>
  83. void swap(T&a, T&b) {
  84.     T c = a;            // langsam, da hier jeweils copy-
  85.     a=b; b=c;        // Konstruktoren verwendet werden
  86. }    
  87.  
  88. // Bubblesort - nicht schnell, aber einfach
  89. template <class T> 
  90. void sort(array<T>&ar) {
  91.     for(int i=0; i<ar.Size()-1; i++) {
  92.         for(int j=ar.Size()-1; i<j; j--) {
  93.             if(ar[j-1] > ar[j])    
  94.                 swap(ar[j], ar[j-1]);    // typsicher!
  95.         }
  96.     }
  97. }    
  98.  
  99. // jede Funktion, die mit Template-Parametern 
  100. // hantiert, muß eine Template-Funktion sein:
  101. template <class T> void PrintArray(array<T>&a) {
  102.     for(int i=0; i<a.Size(); i++)  {
  103.         cout << "a["<<i<<"]: "<<a[i]<<"\n";
  104.         // bei *a vom Typ int wird hier der <<int-Operator
  105.         // von ostream verwandt, bei String der eigene
  106.     }
  107. }
  108.  
  109. void main() {
  110.     char *smp[] = {    "Meyer", "Hoffmann", "Holzmann",
  111.                             "Neumeister", "Schmid", "Peter", 
  112.                             "Werner", "Josef", "Günther", "Willi",
  113.     };
  114.     srand(time(0));
  115.  
  116.     array<String> a(9);    // ein Array aus String-Klassen
  117.     for(int i=0; i<9; i++) {
  118.         a[i] = smp[i];
  119.         // Zuweisung: char* String via operator=
  120.     }
  121.     cout << "unsortiert:\n";    
  122.     PrintArray(a);
  123.     sort(a);
  124.     cout << "\nsortiert:\n";
  125.     PrintArray(a);            
  126.     
  127.     cout << "Taste: "; while(!getchar());
  128.     
  129.     array<int> b(10);
  130.     for(i=0; i<10;i++){
  131.         b[i] = rand();
  132.     }
  133.     cout << "\nints unsortiert:\n";
  134.     PrintArray(b);
  135.     cout << "\nints sortiert:\n";
  136.     sort(b);
  137.     PrintArray(b);
  138.     
  139. } // hier werden die Arrays destruiert
  140.  
  141.  
  142.